/**
 * 系统监控API接口
 */

import { requestClient } from '../../request';
import { onlineList } from '../online';

// 系统健康状态接口
export interface SystemHealthInfo {
  /** 在线用户数 */
  onlineUsers: number;
  /** 系统运行时间（小时） */
  uptime: number;
  /** 系统健康度（0-100） */
  healthScore: number;
  /** CPU使用率（百分比） */
  cpuUsage: number;
  /** 内存使用率（百分比） */
  memoryUsage: number;
  /** 磁盘使用率（百分比） */
  diskUsage: number;
  /** 网络上行速度 (MB/s) */
  networkUpload: number;
  /** 网络下行速度 (MB/s) */
  networkDownload: number;
  /** 数据库连接数 */
  dbConnections: number;
  /** 缓存命中率（百分比） */
  cacheHitRate: number;
  /** 系统温度（摄氏度） */
  temperature: number;
  /** 总内存 (GB) */
  totalMemory: number;
  /** 已用内存 (GB) */
  usedMemory: number;
  /** 总磁盘 (GB) */
  totalDisk: number;
  /** 已用磁盘 (GB) */
  usedDisk: number;
  /** API请求数（每分钟） */
  apiRequests: number;
  /** 错误率（百分比） */
  errorRate: number;
  /** 最后更新时间 */
  updateTime: string;
}

// Redis信息接口（复用现有）
export interface RedisHealthInfo {
  /** 连接状态 */
  connected: boolean;
  /** 使用内存（MB） */
  usedMemory: number;
  /** 连接数 */
  connections: number;
}

/**
 * 获取在线用户数量 - 使用与在线用户页面相同的API
 */
export async function getOnlineUserCount(): Promise<number> {
  try {
    const result = await onlineList();
    // onlineList返回的是PageResult<OnlineUser>，直接使用total字段
    if (result && typeof result === 'object') {
      // 优先使用total字段，如果没有则使用rows数组长度
      if ('total' in result && typeof result.total === 'number') {
        return result.total;
      }
      if ('rows' in result && Array.isArray(result.rows)) {
        return result.rows.length;
      }
    }
    return 0;
  } catch (error) {
    console.error('获取在线用户数失败:', error);
    return 0;
  }
}

/**
 * 获取系统运行时间（模拟数据，实际应从后端获取）
 */
export async function getSystemUptime(): Promise<number> {
  try {
    // 这里应该调用真实的后端API
    // const response = await requestClient.get('/monitor/system/uptime');
    // return response.uptime;
    
    // 临时使用模拟数据：从localStorage获取应用启动时间计算
    const startTime = localStorage.getItem('app_start_time');
    if (startTime) {
      const uptimeMs = Date.now() - parseInt(startTime);
      return Math.floor(uptimeMs / (1000 * 60 * 60)); // 转换为小时
    }
    
    // 如果没有启动时间，设置当前时间并返回0
    localStorage.setItem('app_start_time', Date.now().toString());
    return 0;
  } catch (error) {
    console.error('获取系统运行时间失败:', error);
    return 0;
  }
}

/**
 * 获取系统健康度（模拟计算）
 */
export async function getSystemHealthScore(): Promise<number> {
  try {
    // 这里应该调用真实的后端API
    // const response = await requestClient.get('/monitor/system/health');
    // return response.healthScore;
    
    // 临时模拟计算：基于多个指标综合评分
    const onlineUsers = await getOnlineUserCount();
    const uptime = await getSystemUptime();
    
    // 简单的健康度算法：
    // 在线用户数 > 0: +30分
    // 运行时间 > 1小时: +40分
    // 基础分数: 30分
    let score = 30;
    if (onlineUsers > 0) score += 30;
    if (uptime > 1) score += 40;
    
    // 添加随机波动（85-100之间）
    score = Math.min(100, score + Math.floor(Math.random() * 15));
    
    return score;
  } catch (error) {
    console.error('获取系统健康度失败:', error);
    return 60; // 默认健康度
  }
}

/**
 * 获取系统状态信息
 */
export async function getSystemStatus(): Promise<SystemHealthInfo> {
  try {
    const [onlineUsers, uptime, healthScore] = await Promise.all([
      getOnlineUserCount(),
      getSystemUptime(),
      getSystemHealthScore(),
    ]);

    // 模拟各种系统指标
    const currentHour = new Date().getHours();
    const isBusinessHour = currentHour >= 9 && currentHour <= 18;
    
    // 工作时间和非工作时间有不同的系统负载
    const baseLoad = isBusinessHour ? 0.6 : 0.3;
    const randomFactor = Math.random() * 0.3;
    
    const cpuUsage = Math.min(100, Math.floor((baseLoad + randomFactor) * 100));
    const memoryUsage = Math.min(100, Math.floor((baseLoad * 0.8 + randomFactor) * 100));
    const diskUsage = Math.min(100, Math.floor(45 + Math.random() * 25)); // 45-70%
    
    // 模拟网络流量
    const networkUpload = Number((Math.random() * 10 + 1).toFixed(1));
    const networkDownload = Number((Math.random() * 15 + 5).toFixed(1));
    
    // 模拟其他指标
    const dbConnections = Math.floor(20 + Math.random() * 80);
    const cacheHitRate = Math.floor(85 + Math.random() * 12); // 85-97%
    const temperature = Math.floor(35 + Math.random() * 20); // 35-55度
    
    // 总量模拟
    const totalMemory = 32; // 32GB
    const usedMemory = Number((totalMemory * memoryUsage / 100).toFixed(1));
    const totalDisk = 500; // 500GB
    const usedDisk = Number((totalDisk * diskUsage / 100).toFixed(1));
    
    // API请求和错误率
    const apiRequests = Math.floor(100 + Math.random() * 400); // 100-500 req/min
    const errorRate = Number((Math.random() * 2).toFixed(2)); // 0-2%

    return {
      onlineUsers,
      uptime,
      healthScore,
      cpuUsage,
      memoryUsage,
      diskUsage,
      networkUpload,
      networkDownload,
      dbConnections,
      cacheHitRate,
      temperature,
      totalMemory,
      usedMemory,
      totalDisk,
      usedDisk,
      apiRequests,
      errorRate,
      updateTime: new Date().toISOString(),
    };
  } catch (error) {
    console.error('获取系统状态失败:', error);
    // 返回默认值
    return {
      onlineUsers: 0,
      uptime: 0,
      healthScore: 60,
      cpuUsage: 25,
      memoryUsage: 50,
      diskUsage: 60,
      networkUpload: 2.5,
      networkDownload: 8.0,
      dbConnections: 35,
      cacheHitRate: 90,
      temperature: 42,
      totalMemory: 32,
      usedMemory: 16.0,
      totalDisk: 500,
      usedDisk: 300.0,
      apiRequests: 200,
      errorRate: 0.5,
      updateTime: new Date().toISOString(),
    };
  }
}

/**
 * 获取Redis健康信息（复用现有缓存监控接口）
 */
export async function getRedisHealth(): Promise<RedisHealthInfo> {
  try {
    // 这里可以复用现有的redis缓存信息API
    // const cacheInfo = await redisCacheInfo();
    // return {
    //   connected: true,
    //   usedMemory: parseFloat(cacheInfo.info.used_memory_human?.replace('M', '') || '0'),
    //   connections: parseInt(cacheInfo.info.connected_clients || '0'),
    // };
    
    // 临时使用模拟数据
    return {
      connected: true,
      usedMemory: Math.floor(Math.random() * 500) + 100, // 100-600MB
      connections: Math.floor(Math.random() * 50) + 10,  // 10-60 connections
    };
  } catch (error) {
    console.error('获取Redis健康信息失败:', error);
    return {
      connected: false,
      usedMemory: 0,
      connections: 0,
    };
  }
}